home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DBio / DSeqAsmView.cpp < prev    next >
Text File  |  1996-07-05  |  21KB  |  964 lines
  1. // DSeqAsmView.cpp
  2.  
  3.  
  4. #define TESTVARHEIGHT
  5. #define TESTZOOM
  6. #undef  USEDRAWBASE
  7. #define POPBASECALL
  8.  
  9.  
  10. #include "DSeqViews.h"
  11. #include "DSeqAsmView.h"
  12. #include "DAsmSequence.h"
  13.  
  14. #include <ncbi.h>
  15. #include <dgg.h>
  16. #include <Dvibrant.h>
  17. #include <DApplication.h>
  18. #include <DClipboard.h>
  19. #include <DControl.h>
  20. #include <DWindow.h>
  21. #include <DRichViewNu.h>
  22. #include <DTableView.h>
  23. #include <DViewCentral.h>
  24. #include <DTask.h>
  25. #include <DTracker.h>
  26. #include <DMenu.h>
  27. #include <DUtil.h>
  28. #include <DFindDlog.h>
  29. #include "DSeqFile.h"
  30. #include "DSeqEd.h"
  31. #include "DSeqMail.h"
  32. #include "DSeqCmds.h"
  33. #include "DSeqChildApp.h"
  34. #include "DSeqPrint.h"
  35. #include "DSeqPict.h"
  36. #include "DSeqDoc.h"
  37.  
  38.  
  39.  
  40.  
  41. enum {
  42.     kORFxtraHeight = 4,
  43.     kTracextraHeight = 64,
  44.     kTracePointWidth = 3,  // ?? 1, 2 or 3 ? 
  45.     knadaxxx
  46.     };
  47.     
  48. typedef unsigned long  colorVal;
  49.  
  50. Local short gAlnCharWidth  = 12;
  51. Local short gAlnCharHeight = 15;
  52. Local short gBaseCharWidth = 12;
  53. Local short gRealCharWidth = 12;
  54. Local Boolean gSwapBackground = false;
  55.  
  56. extern "C" void Nlm_SelectBackColor(Nlm_Uint1 red, Nlm_Uint1 green, Nlm_Uint1 blue);
  57. extern "C" void Nlm_SetBackColor (Nlm_Uint4 color);
  58. extern "C" Nlm_Boolean Nlm_MacPopListClick(Nlm_GraphiC m, Nlm_PoinT pt);
  59. extern "C" Nlm_Boolean Nlm_DoClick (Nlm_GraphiC a, Nlm_PoinT pt);
  60. extern "C" Nlm_GraphiC Nlm_GetParent (Nlm_GraphiC a);
  61.  
  62. //inline 
  63. static short BaseCharWidth()
  64. {
  65. #ifdef TESTZOOM
  66.     if (gBaseCharWidth>5) gBaseCharWidth= Nlm_CharWidth('G');
  67.     gRealCharWidth= Nlm_CharWidth('G');
  68. #else
  69.     gBaseCharWidth= gRealCharWidth= Nlm_CharWidth('G');
  70. #endif
  71.     return gBaseCharWidth;
  72. }
  73.  
  74.  
  75. #ifdef POPBASECALL
  76.  
  77. #include "DBaseCallPop.h"
  78.  
  79.  
  80. //DBaseCallPop* gBaseCallPop = NULL;
  81.  
  82.  
  83. DBaseCallPop::DBaseCallPop(long id, DAsmView* itsSuperior):
  84.         DPopupList(id, itsSuperior->fDoc), 
  85.         fAsmView(itsSuperior), 
  86.         fVisible(false), fRow(0), fCol(0) 
  87. {
  88.     Nlm_LoadRect( &fPoprect, 0,0,0,0);
  89.     AddItem("no change"); // default
  90.     AddItem("clear");
  91.     AddItem("set A");
  92.     AddItem("set C");
  93.     AddItem("set G");
  94.     AddItem("set T");
  95.     // ?? stats display at position, other functions at trace position?
  96. }
  97.  
  98.  
  99.  
  100. void DBaseCallPop::LimitTrace(short item)
  101. {
  102. #if 0
  103.             // this isn't working
  104.         // disable choices when trace view is limited to one base !/
  105.     short i;
  106.     item += 3; // convert from base 0..3 to popup item 3..6
  107.     
  108.     if (item<3 || item>6)
  109.         for ( i=3; i<7; i++) SetItemStatus(i,true);
  110.     else {
  111.         for ( i=3; i<7; i++) SetItemStatus(i,false);
  112.         SetItemStatus(item,false);
  113.         }
  114. #endif        
  115. }
  116.  
  117. void DBaseCallPop::Hold(Nlm_PoinT mouse)
  118. {
  119.   Nlm_GraphiC m = Nlm_GetParent ((Nlm_GraphiC)fPopup);
  120. #ifdef WIN_MAC
  121.     if ( Nlm_DoClick( (Nlm_GraphiC) m, mouse) ) ;
  122.         // !! WORKS, gets us to DSeqAsmDoc::IsMyAction(kBaseCallPop) 
  123. #endif
  124.  
  125. }
  126.          
  127.  
  128. void DBaseCallPop::Release(Nlm_PoinT mouse)
  129. {
  130.     //Message(MSG_OK,"DBaseCallPop::Release"); // this is seen
  131. }
  132.  
  133.  
  134. Boolean DBaseCallPop::IsMyAction(DTaskMaster* action) 
  135. {
  136.     switch(action->Id()) {
  137.             
  138.      case kBaseCallPopup: {
  139.                  // call here from DSeqAsmDoc::IsMyAction()
  140.         DAsmSequence* aSeq = NULL;
  141.         TraceBase tr, * tra = NULL;
  142.         Boolean doupdate= false;
  143.         short    mode= this->GetValue();
  144.         long    i, maxcol= 0, atcol = fCol;
  145.         
  146.         if (mode>1) {  
  147.             aSeq= (DAsmSequence*)fAsmView->fSeqList->SeqAt(fRow);
  148.             maxcol= aSeq->NumPoints();
  149.             if (mode>2) // make sure we don't overwrite other base!
  150.                 for (i=0; 
  151.                     aSeq->TraceAt(atcol).base>' ' && atcol<maxcol && i<20; 
  152.                     i++, atcol++) ;
  153.             tr = aSeq->TraceAt(atcol);
  154.             }
  155.             
  156.         switch (mode) {
  157.             case 1:  break;  // nothing...
  158.             case 2:  tr.base= 0; doupdate= true; break;     
  159.             case 3:  tr.base= 'A'; doupdate= true; break;  
  160.             case 4:  tr.base= 'C'; doupdate= true; break;     
  161.             case 5:     tr.base= 'G'; doupdate= true; break; 
  162.             case 6:  tr.base= 'T'; doupdate= true; break;
  163.             }
  164.             
  165.         if (doupdate) {
  166.             Nlm_RecT  r;
  167.             aSeq->SetTraceAt(atcol, tr);
  168.             aSeq->SetChanged(true);
  169.             // !! need to update aSeq->fBases sometime w/ new set !!
  170.             // need undo/redo of change !
  171.             
  172.             fAsmView->GetCellRect(fRow, fCol, r);  
  173.             r.left  = Min( r.left, fPoprect.left-20);
  174.             r.right = Max( r.right, fPoprect.right+20);
  175.             fAsmView->InvalRect( r);  // fPoprect
  176.  
  177.             if (fAsmView->fDoc->fAlnIndex) {
  178.                 fAsmView->fDoc->fAlnIndex->GetRowRect( fRow, r);
  179.                 fAsmView->fDoc->fAlnIndex->InvalRect( r);
  180.                 }
  181.             }
  182.       return true;
  183.         }
  184.         
  185.         default:
  186.             return DPopupList::IsMyAction(action);
  187.         }
  188. }
  189.  
  190.  
  191.  
  192. void DBaseCallPop::Show(Nlm_PoinT mouse)
  193. {
  194.     long row, col;
  195.  
  196.     fAsmView->PointToCell( mouse, row, col);
  197.     if (col) col--; // fix off-by-one error
  198.     if ( row >=0 && row < fAsmView->GetMaxRows()
  199.      && col >= 0 && col < fAsmView->GetMaxCols()) {
  200.         Nlm_RecT  r;
  201.         short   w, h;
  202.         fMouse= mouse;
  203.         fRow= row;
  204.         fCol= col;
  205.  
  206.         this->GetPosition(r);
  207.         w= r.right - r.left;
  208.         h= r.bottom- r.top;
  209.         r.left= mouse.x - 10;  // make sure mouse is in rect..
  210.         r.top = mouse.y - 10;
  211.         r.right= r.left + w;
  212.         r.bottom= r.top + h;
  213.         fPoprect= r;
  214.         this->SetPosition(r);        
  215.         
  216.         Show();
  217.         }
  218. }
  219.  
  220. void DBaseCallPop::Show()
  221. {
  222.     if (!fVisible) {
  223.         fVisible= true;
  224.         DPopupList::Show(); 
  225.         this->SetValue(1); // ?? force label to show?
  226.         Enable();
  227.         }
  228. }
  229.  
  230. void DBaseCallPop::Hide()
  231. {
  232.     if (fVisible) {
  233.         fVisible= false;
  234.         Disable();
  235.         DPopupList::Hide();
  236.         fAsmView->InvalRect(fPoprect);
  237.         }
  238. }
  239.  
  240. #endif
  241.  
  242.  
  243.  
  244.  
  245.  
  246. //class DAsmView : public DAlnView  
  247.  
  248.  
  249. DAsmView::DAsmView( long id, DView* itsSuper, DSeqDoc* itsDocument, DSeqList* itsSeqList, 
  250.                                 long pixwidth, long pixheight) :
  251.     DAlnView( id, itsSuper, itsDocument, itsSeqList,  pixwidth,  pixheight),
  252.     fHaveAutoseq(false), fBaseOnTrace(true)                  
  253. { 
  254.     fKind= kindAlnView;
  255.     for (short t=0; t<4; t++) fShowTrace[t]= true;
  256.     
  257. #ifdef TESTZOOM
  258.     //DSequence* aSeq= fSeqList->SeqAt(0);
  259.     if (1) { // (aSeq && aSeq->ShowTrace())
  260.         fHaveAutoseq= true;
  261.         gBaseCharWidth= kTracePointWidth; 
  262.         }
  263.     else gBaseCharWidth= Nlm_stdCharWidth;
  264. #endif
  265.  
  266.     gAlnCharWidth= gBaseCharWidth; //Nlm_stdCharWidth; //BaseCharWidth();   
  267.     gAlnCharHeight= Nlm_stdLineHeight;
  268.     
  269. #ifdef POPBASECALL
  270.   Nlm_PoinT  nps, saveps;
  271. #if 1
  272.     fDoc->GetNextPosition( &saveps);
  273.     nps.x= 1; nps.y= 1; // locate dialog item 
  274.     fDoc->SetNextPosition( nps);
  275. #endif
  276.     
  277.     DBaseCallPop* bcpop= new DBaseCallPop( kBaseCallPopup, this);  
  278.     fBaseCallPop= bcpop;  
  279.     bcpop->fVisible= true;
  280.     bcpop->Hide();  
  281. #if 1
  282.     fDoc->SetNextPosition( saveps);
  283. #endif
  284. #endif
  285.  
  286. }
  287.  
  288.  
  289. DAsmView::~DAsmView()
  290. {
  291. }
  292.  
  293.                 
  294.  
  295. void DAsmView::CheckViewCharWidth()
  296. {
  297.     if (fEditSeq) {
  298.         Nlm_RecT vr;
  299.         ViewRect( vr);
  300.         long cwidth= (vr.right - vr.left) / GetItemWidth(0);
  301.         fEditSeq->SetColumns( cwidth);
  302.         }
  303. }
  304.  
  305.  
  306. void DAsmView::GetReadyToShow()
  307. {
  308.     // assume port is set??
  309.     SelectFont();  
  310.     gAlnCharWidth = BaseCharWidth();   
  311.         // use Nlm_FontHeight for background color to adjoin among rows
  312.     gAlnCharHeight= Nlm_FontHeight(); //Nlm_LineHeight(); // + 2; 
  313.     
  314.     //SetItemWidth(0, GetMaxCols(), gAlnCharWidth); // done in UpdateAllWidths
  315.     this->UpdateAllWidths(); 
  316.     this->UpdateSize();  // need before GetMaxRows()!
  317.  
  318. #ifdef TESTVARHEIGHT
  319.     long i, nrow= GetMaxRows();
  320.     for (i= 0; i<nrow; i++) {
  321.         short ht= gAlnCharHeight;
  322.         DSequence* aSeq= fSeqList->SeqAt(i);
  323.         if (aSeq && aSeq->ShowORF()) ht += kORFxtraHeight;
  324.         if (aSeq && aSeq->ShowTrace()) ht += kTracextraHeight;
  325.         SetItemHeight(i, 1, ht);
  326.         }    
  327. #else
  328.     SetItemHeight(0, GetMaxRows(), gAlnCharHeight);
  329. #endif
  330. }
  331.  
  332.  
  333.  
  334.  
  335.  
  336. void DAsmView::Drag(Nlm_PoinT mouse)
  337. {
  338.     DAlnView::Drag(mouse); // sets fMouseStillDown= true
  339. }
  340.  
  341. void DAsmView::Hold(Nlm_PoinT mouse)
  342. {
  343. #ifdef POPBASECALL
  344.     if (fBaseCallPop) {
  345.         if (!fBaseCallPop->fVisible) fBaseCallPop->Show(mouse);
  346.         if ( fBaseCallPop->fVisible) fBaseCallPop->Hold(mouse);
  347.         }
  348. #endif
  349.     DAlnView::Hold(mouse);
  350. }
  351.  
  352. void DAsmView::Release(Nlm_PoinT mouse)
  353. {
  354. #ifdef POPBASECALL
  355.     if (fBaseCallPop) {
  356.       if ( fBaseCallPop->fVisible) fBaseCallPop->Hide();
  357.         if (!fBaseCallPop->fVisible) fBaseCallPop->Release(mouse);
  358.         }
  359. #endif
  360.     DAlnView::Release(mouse);
  361. }
  362.  
  363. void DAsmView::DoubleClickAt(long row, long col)
  364. {
  365. }
  366.  
  367. void DAsmView::Click(Nlm_PoinT mouse)
  368. { 
  369. #if 0
  370.     DAlnView::Click( mouse);
  371. #else
  372.     long     row, col;
  373.     Nlm_CaptureSlateFocus((Nlm_SlatE) fPanel); // for CharHandler !
  374.     PointToCell( mouse, row, col);
  375.     SeqMeter(row,col);
  376.     if (fMaskLevel<1 && IsSelected(row, col)) {
  377.  
  378.         }
  379.     else {
  380.         fTabSelector= new DTabSelector( this);
  381.         fCurrentTracker= fTabSelector;
  382.         }
  383.     DTableView::Click( mouse);
  384. #endif
  385. }
  386.  
  387.  
  388. void DAsmView::TrackMouse( short aTrackPhase,
  389.                     Nlm_PoinT& anchorPoint, Nlm_PoinT& previousPoint,
  390.                     Nlm_PoinT& nextPoint,    Nlm_Boolean mouseDidMove)
  391. {
  392.     DAlnView::TrackMouse( aTrackPhase, anchorPoint, previousPoint, nextPoint,mouseDidMove); 
  393. }
  394.  
  395.  
  396. void DAsmView::TrackFeedback( short aTrackPhase,
  397.                     const Nlm_PoinT& anchorPoint, const Nlm_PoinT& previousPoint,
  398.                     const Nlm_PoinT& nextPoint, Nlm_Boolean mouseDidMove, Nlm_Boolean turnItOn)
  399. {
  400. #if 1
  401.     DAlnView::TrackFeedback( aTrackPhase, anchorPoint, previousPoint, nextPoint,
  402.                     mouseDidMove, turnItOn);
  403. #else
  404.     long     row, col;
  405.     if (mouseDidMove && aTrackPhase == DTracker::trackContinue ) { // 2 == trackContinue
  406.         PointToCell( nextPoint, row, col);
  407.         SeqMeter(row,col);
  408.         }
  409.     DTableView::TrackFeedback( aTrackPhase, anchorPoint, previousPoint, nextPoint,
  410.                     mouseDidMove, turnItOn);
  411. #endif
  412. }
  413.  
  414.  
  415. void DAsmView::SingleClickAt(long row, long col)
  416. {
  417. #if 1
  418.          DAlnView::SingleClickAt(row,  col);
  419. #else
  420.     if (!(fLocked || gKeys->shift() || gKeys->command() || gKeys->option() )) {  
  421.         SetEmptySelection( true); 
  422.         if (fDoc->fAlnIndex) fDoc->fAlnIndex->SetEmptySelection( true); 
  423.         InstallEditSeq(row,col,col,false);
  424.         }
  425.     else     if (fMaskLevel>0) {
  426.         Nlm_RecT r;
  427.         DSequence* ag= fSeqList->SeqAt(row); 
  428.         if (ag) {
  429.             if (gKeys->shift()) ag->SetMaskAt(col,fMaskLevel);
  430.             else ag->FlipMaskAt(col,fMaskLevel);
  431.             }
  432.         GetCellRect( row, col, r);
  433.         InvalRect( r);
  434.         }
  435.     else
  436.          DTableView::SingleClickAt(row,  col);
  437. #endif
  438. }
  439.  
  440.     
  441.  
  442.  
  443. void DAsmView::Scroll(Boolean vertical, DView* scrollee, long newval, long oldval)
  444. {
  445.     DAlnView::Scroll(vertical, scrollee, newval, oldval);
  446. }
  447.  
  448.  
  449.  
  450.  
  451.  
  452. void DAsmView::UpdateWidth(DSequence* aSeq)
  453. {     
  454.     long alnlen;
  455.     if (fHaveAutoseq)  
  456.         alnlen= ((DAsmSequence*)aSeq)->NumPoints() + 30;
  457.     else
  458.         alnlen= aSeq->LengthF() + 30;
  459.     if (alnlen > GetMaxCols()) ChangeColSize( -1, alnlen-GetMaxCols());  
  460.     SetItemWidth( 0, GetMaxCols(), gAlnCharWidth); 
  461.     if (fMaskLevel>0 || aSeq->Masks()) aSeq->FixMasks();
  462. }
  463.  
  464. void DAsmView::UpdateAllWidths()
  465. {
  466.     long alnlen= 0;
  467.     long i, nseq= fSeqList->GetSize();
  468.     for (i=0; i<nseq; i++) {
  469.         DSequence* aSeq= fSeqList->SeqAt(i);
  470.         if (fHaveAutoseq)  
  471.             alnlen= Max( alnlen, ((DAsmSequence*)aSeq)->NumPoints());
  472.         else
  473.             alnlen= Max(alnlen, aSeq->LengthF()); 
  474.         if (fMaskLevel>0 || aSeq->Masks()) aSeq->FixMasks();
  475.         }
  476.     alnlen += 30; 
  477.     if (alnlen > GetMaxCols()) ChangeColSize( -1, alnlen-GetMaxCols());
  478.     SetItemWidth( 0, GetMaxCols(), gAlnCharWidth);  
  479.     //if (fDoc && fDoc->fAlnHIndex) fDoc->fAlnHIndex->UpdateWidth(); //keep ruler in sync
  480. }
  481.  
  482.  
  483.  
  484. void DAsmView::SetViewMode(short viewmode) 
  485. {
  486.     short  t, i;
  487.     switch (viewmode) {
  488.     
  489.         case kShowTraces: 
  490.             for (t=0; t<4; t++) fShowTrace[t]= true;
  491.             this->fMaskLevel= 1;
  492.             fBaseCallPop->LimitTrace(-1);
  493.             goto caseMainSet;
  494.             
  495.         case kShowTraceA: 
  496.             i= 0; goto caseTraceI;
  497.         case kShowTraceC: 
  498.             i= 1; goto caseTraceI;
  499.         case kShowTraceG: 
  500.             i= 2; goto caseTraceI;
  501.         case kShowTraceT: 
  502.             i= 3; //goto caseTraceI;
  503.         caseTraceI:
  504.             for (t=0; t<4; t++) fShowTrace[t]= false;
  505.             fShowTrace[i]= true;
  506.             fBaseCallPop->LimitTrace(i);
  507.             this->fMaskLevel= 1;
  508.             // goto caseMainSet;
  509.         case kModeSlide: 
  510.         caseMainSet:
  511.             this->SetTextLock( true);
  512.             if (this->fMaskLevel>0) this->Invalidate();
  513.             this->fMaskLevel= 0; 
  514.             break;
  515.             
  516.         case kModeEdit:  
  517.             this->SetTextLock( false);
  518.             if (this->fMaskLevel>0) this->Invalidate();
  519.             this->fMaskLevel= 0; 
  520.             break;
  521.             
  522.         default :
  523.             break;
  524.         }
  525. }
  526.  
  527.  
  528.  
  529.  
  530.  
  531.  
  532.  
  533.  
  534.  
  535.  
  536. static void DrawTrace( long atx, long y0, short t, TraceBase* trace, 
  537.                     long startcol, long stopcol, short cwidth, float scale)
  538. {
  539. #define kTYScale 0.25     // need Scale of ht !
  540.     //short    cwidth= GetItemWidth(0); 
  541.     long aty;
  542.     Nlm_MoveTo(atx, y0);
  543.     for (long i= startcol+1; i<stopcol; i++) {
  544.         //if (fWidths) atx += GetItemWidth(i); else
  545.         atx += cwidth;
  546.         aty = y0 - (long)(trace[i].tr[t] * scale);
  547.         Nlm_LineTo( atx, aty);
  548.         }
  549. }
  550.  
  551.  
  552. #ifdef USEDRAWBASE
  553.  
  554. class DrawBasesA
  555. {
  556. public:
  557.     Nlm_PoinT pt;
  558.     long            endx, pend, indx, len, cw, cht;
  559.     long            row, ytop, ybot;
  560.     char            ch, lastch, *pText;
  561.     DAsmView * tview;
  562.     Boolean      swapBackcolor, fDoAll;
  563.     float         fScale;
  564.     char            fAtch;
  565.     Boolean     fIsGrey;
  566.     
  567.     DrawBasesA() : fIsGrey(false) {}
  568.     virtual void doDraw(DAsmView* theView, baseColors theColors, Boolean backcolor,
  569.                char*    theText, long theIndx, long theLen, long theRow);
  570.     virtual void Calc();
  571.     
  572.     virtual void DrawSub(baseColors colors);
  573.     virtual void DrawORFMasks(baseColors colors, short masklevel);
  574.     virtual void DrawTraces(baseColors colors);
  575. };
  576.  
  577. class DrawGreyBasesA : public DrawBasesA
  578. {
  579. public:    
  580.     DrawGreyBasesA() { fIsGrey = true; }
  581. };
  582.  
  583.  
  584.  
  585. void DrawBasesA::Calc() 
  586. {
  587.     long skip;
  588.     cht= tview->GetItemHeight(row);
  589.     cw = tview->GetItemWidth(0); 
  590.  
  591.     DAsmSequence* aSeq= (DAsmSequence*) tview->fCurSeq;
  592.     fScale= kTracextraHeight;
  593.     short t, att, nt;
  594.     for (t= 0, att= 0, nt= 0; t<4; t++) if (tview->fShowTrace[t]) { att= t; nt++; } 
  595.     if (nt==1) {
  596.         switch (att) {
  597.             case 0: fAtch= 'A'; break;
  598.             case 1: fAtch= 'C'; break;
  599.             case 2: fAtch= 'G'; break;
  600.             case 3: fAtch= 'T'; break;
  601.             }
  602.         fScale /= aSeq->MaxHeight(att);
  603.         fDoAll= false;
  604.         }
  605.     else {
  606.         fDoAll= true;
  607.         fScale /= aSeq->MaxHeight(4);
  608.         }
  609.         
  610.     Nlm_GetPen( &pt);
  611.     ytop= pt.y-cht+2;
  612.     ybot= pt.y+2;  
  613.     if (pt.x < 0) {
  614.         skip= (-pt.x) / cw;
  615.       indx+= skip;
  616.         len -= skip;
  617.         Nlm_MoveTo( pt.x + skip*cw, pt.y);
  618.         }
  619.     pend= len * cw;
  620.     
  621.     if (pend > tview->GetRect().right) {   
  622.         skip= (pend - tview->GetRect().right) / cw;  
  623.         len -= skip;
  624.         }
  625.     endx= indx + len - 1;
  626. }
  627.  
  628.  
  629.  
  630.  
  631. void DrawBasesA::doDraw(DAsmView* theView, baseColors theColors, Boolean backcolor,
  632.            char*    theText, long theIndx, long theLen, long theRow)
  633. {
  634.     tview= theView;
  635.     //colors= &theColors;
  636.     pText= theText;
  637.     indx= theIndx;
  638.     len= theLen;
  639.     row= theRow;
  640.     lastch= 0;
  641.     swapBackcolor= backcolor;
  642.  
  643.     Calc();
  644.  
  645.     if (swapBackcolor) Nlm_CopyMode();
  646.     Nlm_PoinT savept= pt;
  647.     
  648. #if 1
  649.     if (tview->fCurSeq->ShowTrace()) {
  650.         pt= savept;
  651.         pt.y -= 2;  
  652.         DrawTraces(theColors);        
  653.         savept.y -= kTracextraHeight;
  654.         pt= savept;
  655.         Nlm_MoveTo( pt.x, pt.y);
  656.         }
  657. #endif        
  658.  
  659. #if 1
  660.     if (tview->fCurSeq->ShowORF()) {
  661.         pt= savept;
  662.         pt.y -= (kORFxtraHeight - 3);
  663.         DrawORFMasks(theColors, 5);            
  664.         //pt= savept; pt.y -= 7;
  665.         //DrawORFMasks(theColors, 6);            
  666.         //pt= savept; /pt.y - 2;
  667.         //DrawORFMasks(theColors, 7);            
  668.         
  669.         savept.y -= kORFxtraHeight;
  670.         pt= savept;
  671.         Nlm_MoveTo( pt.x, pt.y);
  672.         }
  673. #endif
  674.  
  675.     DrawSub(theColors);
  676.     
  677. #if 0
  678.     if (tview->fCurSeq->ShowRE()) {
  679.         DrawREMasks();            
  680.         }
  681. #endif
  682.  
  683.     if (swapBackcolor) Nlm_MergeMode();
  684. }
  685.  
  686.  
  687.  
  688. void DrawBasesA::DrawSub(baseColors colors)
  689. {
  690.     Nlm_RecT    crec;  
  691.     DAsmSequence* aSeq= (DAsmSequence*) tview->fCurSeq;
  692.     TraceBase* trace= aSeq->Trace();
  693.     
  694.     for (long i= indx; i<=endx; i++) {
  695.  
  696.         Boolean notInverted= true;
  697.         ch= trace[i].base;
  698.  
  699.         if ( (fDoAll && ch > ' ') || ch == fAtch) {
  700.             //if (fIsGrey) {
  701.                 //if (swapBackcolor) Nlm_SetBackColor( tview->fColcolors[i-indx]);  else 
  702.                 //Nlm_SetColor( tview->fColcolors[i-indx]);
  703.                 //}
  704.             //else 
  705.             if (ch!=lastch) {
  706.                 //if (swapBackcolor) Nlm_SetBackColor( colors[ch-' ']);  else 
  707.                 Nlm_SetColor( colors[ch-' ']);
  708.                 }
  709.                 
  710.             Nlm_PaintChar(ch);
  711.             lastch= ch;
  712.             }
  713.                 
  714.         if (notInverted) {
  715.           if (tview->fSelection->IsSelected(row, i)) {
  716.                 Nlm_LoadRect( &crec, pt.x, ytop, pt.x+cw, ybot); //??
  717.                 tview->DTableView::InvertRect( crec);
  718.                 }
  719.             }
  720.             
  721.         pt.x += cw;
  722.         }
  723.     Nlm_Black();
  724. }
  725.  
  726.  
  727.  
  728. void DrawBasesA::DrawTraces(baseColors colors)
  729. {
  730.     DAsmSequence* aSeq= (DAsmSequence*) tview->fCurSeq;
  731.     for (short t= 0; t<4; t++) if (tview->fShowTrace[t]) {
  732.         char ch;
  733.         switch (t) {
  734.             case 0: ch= 'A'; break;
  735.             case 1: ch= 'C'; break;
  736.             case 2: ch= 'G'; break;
  737.             case 3: ch= 'T'; break;
  738.             }
  739.         Nlm_SetColor( colors[ch-' ']);
  740.         ::DrawTrace( pt.x, pt.y, t, aSeq->Trace(), indx, endx, cw, fScale);
  741.         }
  742.     Nlm_Black();
  743. }
  744.  
  745.  
  746. // this should move into DSeqView's DrawBases class !! not useful w/ trace view 
  747. void DrawBasesA::DrawORFMasks(baseColors colors, short masklevel)
  748. {
  749.     enum { otic = 3 };
  750.     long        lastx, startx = pt.x;
  751.     Boolean inorf= false;
  752.     
  753.     for (long i= indx; i<=endx; i++) {
  754.         ch= pText[i];
  755.         if (ch >= ' ') {
  756.             short maskval= tview->fCurSeq->MaskAt(i, masklevel);
  757.             if (maskval && !inorf) { 
  758.                 startx= lastx= pt.x; 
  759.                 inorf= true; 
  760.                 }
  761.             else if ( !maskval 
  762.                 && inorf 
  763.                 && (DSequence::NucleicBits(ch) != DSequence::kMaskIndel)
  764.                 ) {
  765.                 Nlm_MoveTo( startx, pt.y-otic);
  766.                 Nlm_LineTo( startx, pt.y);
  767.                 Nlm_LineTo( lastx, pt.y);
  768.                 Nlm_LineTo( lastx, pt.y-otic);
  769.                 inorf= false;
  770.                 }
  771.             lastx= pt.x;
  772.             pt.x += cw;
  773.             }
  774.         }
  775.     if (inorf) {
  776.         Nlm_MoveTo( startx, pt.y-otic);
  777.         Nlm_LineTo( startx, pt.y);
  778.         Nlm_LineTo( pt.x, pt.y);
  779.         inorf= false;
  780.         }
  781.         
  782.     //Nlm_Black();
  783. }
  784.  
  785.     
  786. DrawBasesA         gDrawBasesA;
  787. DrawGreyBasesA     gDrawGreyBasesA;
  788. #endif  // USEDRAWBASE
  789.  
  790.  
  791. Local Boolean          gDoDrawColors = false;
  792.  
  793. void DAsmView::DrawAllColors(Nlm_RecT r, long row)
  794. { 
  795.     DAsmSequence* aSeq= (DAsmSequence*)fSeqList->SeqAt(row);
  796.     if (!aSeq || !aSeq->Bases()) return;
  797.     
  798.     Boolean dotrace= aSeq->ShowTrace() && (aSeq->Kind() == DAsmSequence::kAutoseq);
  799.     if (!dotrace) { DAlnView::DrawAllColors( r, row); return; }
  800.  
  801. #ifndef USEDRAWBASE
  802.     gDoDrawColors= true;
  803.     DrawNoColors( r, row);
  804.     gDoDrawColors= false;
  805.     
  806. #else
  807.     long  len, newright, stopcol, startcol = GetLeft(); 
  808.     char* hSeq= aSeq->Bases();
  809.     fCurSeq= aSeq;
  810.  
  811.     for (stopcol= startcol, newright= r.left; 
  812.         stopcol<GetMaxCols() && newright<r.right;
  813.         stopcol++) {
  814.         if (fWidths) newright += GetItemWidth(stopcol); else 
  815.         newright += GetItemWidth(0);
  816.         }
  817.             
  818.     len= Min( stopcol, ((DAsmSequence*)aSeq)->NumPoints());
  819.     //len= Min( aSeq->LengthF(), stopcol);
  820.     len -= startcol;
  821.     if (len>0) {
  822.         Nlm_MoveTo( r.left, r.bottom-2); //bottom-5
  823. #if 0
  824.         if (aSeq->Kind() == DSequence::kAmino)
  825.             gDrawBasesA.doDraw(this, DBaseColors::gAAcolors, gSwapBackground,
  826.                      hSeq, startcol, len, row);
  827.         else
  828. #endif
  829.             gDrawBasesA.doDraw(this, DBaseColors::gNAcolors, gSwapBackground,
  830.                      hSeq, startcol, len, row);
  831.         }
  832.  
  833.     fColsDrawn= stopcol - startcol;
  834. #endif
  835. }  
  836.  
  837.  
  838.  
  839. void DAsmView::DrawNoColors(Nlm_RecT r, long row)
  840. { 
  841.     DAsmSequence* aSeq= (DAsmSequence*)fSeqList->SeqAt(row);
  842.     if (!aSeq || !aSeq->Bases()) return;
  843.     
  844.     Boolean dotrace= aSeq->ShowTrace() && (aSeq->Kind() == DAsmSequence::kAutoseq);
  845.     if (!dotrace) { DAlnView::DrawNoColors( r, row); return; }
  846.     
  847.     long  y0, len, atx, aty, stopcol, startcol = GetLeft(), newright;
  848.     short cwidth= GetItemWidth(0); 
  849.     TraceBase* trace = aSeq->Trace();
  850.     if (!trace) return; // early calls here before traces read !
  851.     
  852.     for (stopcol= startcol, newright= r.left; 
  853.         stopcol<GetMaxCols() && newright<r.right; 
  854.         stopcol++) {
  855.             //if (fWidths) newright += GetItemWidth(stopcol); else 
  856.             newright += cwidth;
  857.             }
  858.     
  859.     //len= Min( aSeq->LengthF(), stopcol);
  860.     len = Min( stopcol, ((DAsmSequence*)aSeq)->NumPoints());  
  861.     len -= startcol;
  862.     if (len>0) {
  863.         atx= r.left;
  864.         aty= y0 = r.bottom-2;
  865.         stopcol= startcol + len;
  866.  
  867.         float scale = kTracextraHeight;
  868.         short t, att, nt;
  869.         char ch, atch, lastch= 0;
  870.         short xoffset= gRealCharWidth / 2;
  871.         
  872.         for (t= 0, att= 0, nt= 0; t<4; t++) if (this->fShowTrace[t]) { att= t; nt++; } 
  873.         if (nt==1) {
  874.             switch (att) {
  875.                 case 0: atch= 'A'; break;
  876.                 case 1: atch= 'C'; break;
  877.                 case 2: atch= 'G'; break;
  878.                 case 3: atch= 'T'; break;
  879.                 }
  880.             scale /= aSeq->MaxHeight(att);
  881.             }
  882.         else scale /= aSeq->MaxHeight(4);
  883.         
  884.                 // draw traces
  885.         if (aSeq->ShowTrace()) {
  886.           for ( t= 0; t<4; t++)
  887.           if (fShowTrace[t]) {
  888.                 switch (t) {
  889.                     case 0: ch= 'A'; break;
  890.                     case 1: ch= 'C'; break;
  891.                     case 2: ch= 'G'; break;
  892.                     case 3: ch= 'T'; break;
  893.                     }
  894.                 if (gDoDrawColors) Nlm_SetColor( DBaseColors::gNAcolors[ch-' ']);
  895.                 ::DrawTrace( atx, aty, t, aSeq->Trace(), startcol, stopcol, cwidth, scale);
  896.                 }
  897.             Nlm_Black();
  898.             aty -= ( kTracextraHeight - 2); //??
  899.             }
  900.         
  901.             // draw ORFs
  902.         if (aSeq->ShowORF()) {
  903.             aty -= ( kORFxtraHeight ); //??
  904.             }
  905.         
  906.             // draw bases
  907.         aty= r.top + gAlnCharHeight - 2; //??
  908.         for (long i= startcol; i<stopcol; i++) {
  909.             long y1, x1;
  910.             ch= trace[i].base;
  911.             if ( (nt  > 1 && ch > ' ')
  912.               || (nt == 1 && ch == atch)) {
  913.  
  914.                 if (lastch != ch && gDoDrawColors) 
  915.                     Nlm_SetColor( DBaseColors::gNAcolors[ch-' ']);
  916.  
  917.                 switch (ch) {
  918.                     case 'A': t= 0; break;
  919.                     case 'C': t= 1; break;
  920.                     case 'G': t= 2; break;
  921.                     case 'T': t= 3; break;
  922.                     }
  923.                     
  924.                 if (fBaseOnTrace) { 
  925.                     y1 = Max( aty, y0 - (long)(trace[i].tr[t] * scale) - 2);
  926.                     }
  927.                 else 
  928.                     y1= aty;
  929.                 
  930.                 Nlm_MoveTo(atx - xoffset, y1);
  931.                 Nlm_PaintChar(ch);
  932.                 lastch= ch;
  933.                 }
  934.           if (this->fSelection->IsSelected(row, i)) {
  935.                 Nlm_RecT crec;
  936.                 Nlm_LoadRect( &crec, atx, r.top, atx+cwidth, r.bottom); 
  937.                 DTableView::InvertRect( crec); 
  938.                 }
  939.             //if (fWidths) atx += GetItemWidth(i); else
  940.             atx += cwidth;
  941.             }
  942.       }
  943.     Nlm_Black();
  944.     fColsDrawn= stopcol - startcol;
  945. }  
  946.  
  947.         
  948. void DAsmView::Draw()
  949. {
  950.     DAlnView::Draw();
  951. }
  952.  
  953.  
  954. void DAsmView::DrawRow(Nlm_RecT r, long row)
  955. {
  956.     DAlnView::DrawRow(r, row);
  957. }
  958.  
  959.         
  960.  
  961.  
  962.  
  963.  
  964.